<!DOCTYPE html>
<html lang="zh-cn">
<head>
   
    <link type="text/css" rel="stylesheet" href="/bundles/blog-common.css?v=KOZafwuaDasEedEenI5aTy8aXH0epbm6VUJ0v3vsT_Q1"/>
<link id="MainCss" type="text/css" rel="stylesheet" href="/skins/ThinkInside/bundle-ThinkInside.css?v=RRjf6pEarGnbXZ86qxNycPfQivwSKWRa4heYLB15rVE1"/>
<link type="text/css" rel="stylesheet" href="/blog/customcss/428549.css?v=%2fam3bBTkW5NBWhBE%2fD0lcyJv5UM%3d"/>

</head>
<body>
<a name="top"></a>

<div id="page_begin_html"></div><script>load_page_begin_html();</script>

<div id="topics">
	<div class = "post">
		<h1 class = "postTitle">
			<a id="cb_post_title_url" class="postTitle2" href="https://www.cnblogs.com/frankdeng/p/9301798.html">Spark（八）JVM调优以及GC垃圾收集器</a>
		</h1>
		<div class="clear"></div>
		<div class="postBody">
			<div id="cnblogs_post_body" class="blogpost-body"><h2>一JVM结构</h2>
<h3 id="blogTitle1">1 Java内存结构</h3>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430151809602-1476931965.png" alt="" /></p>
<p>JVM内存结构主要有三大块：<strong>堆内存、方法区和栈</strong>。</p>
<p><strong>堆内存</strong>是JVM中最大的一块由年轻代和老年代组成，而年轻代内存又被分成三部分，<span class="16">Eden空间、<span class="16">From Survivor空间、<span class="16">To Survivor空间<span class="16">,默认情况下年轻代按照8:1:1的比例来分配；</span></span></span></span></p>
<p><span class="16"><strong>方法区</strong>存储类信息、常量、静态变量等数据，是线程共享的区域，为与Java堆区分，方法区还有一个别名Non-Heap(非堆)；</span></p>
<p><span class="16"><strong>栈</strong>又分为java虚拟机栈和本地方法栈主要用于方法的执行。</span></p>
<h3 id="blogTitle2">2 各区域内存大小</h3>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430152017807-1294956408.png" alt="" /></p>
<h3 id="blogTitle3">3 控制参数</h3>
<p>-Xms设置堆的最小空间大小。</p>
<p>-Xmx设置堆的最大空间大小。</p>
<p>-XX:NewSize设置新生代最小空间大小。</p>
<p>-XX:MaxNewSize设置新生代最大空间大小。</p>
<p>-XX:PermSize设置永久代最小空间大小。</p>
<p>-XX:MaxPermSize设置永久代最大空间大小。</p>
<p>-Xss设置每个线程的堆栈大小。</p>
<p>没有直接设置老年代的参数，但是可以设置堆空间大小和新生代空间大小两个参数来间接控制。</p>
<p><strong>&nbsp;&nbsp;老年代空间大小=堆空间大小-年轻代大空间大小</strong></p>
<h3 id="blogTitle4">4 JVM和系统调用间的关系</h3>
<p>&nbsp;<img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430152138687-378200875.png" alt="" /></p>
<p><strong>方法区和堆是所有线程共享的内存区域；而java栈、本地方法栈和程序员计数器是运行是线程私有的内存区域。</strong></p>
<h2 id="blogTitle5">二JVM各区域的作用</h2>
<h3 id="blogTitle6">1 Java堆</h3>
<p>&nbsp;&nbsp;&nbsp;&nbsp;对于大多数应用来说，Java堆（Java Heap）是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp; Java堆是垃圾收集器管理的主要区域，因此很多时候也被称做&ldquo;GC堆&rdquo;。如果从内存回收的角度看，由于现在收集器基本都是采用的分代收集算法，所以Java堆中还可以细分为：新生代和老年代；再细致一点的有Eden空间、From Survivor空间、To Survivor空间等。</p>
<p>根据Java虚拟机规范的规定，Java堆可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可，就像我们的磁盘空间一样。在实现时，既可以实现成固定大小的，也可以是可扩展的，不过当前主流的虚拟机都是按照可扩展来实现的（通过-Xmx和-Xms控制）。</p>
<p>如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。</p>
<h3 id="blogTitle7">2 方法区</h3>
<p>&nbsp; 方法区（Method Area）与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做Non-Heap（非堆），目的应该是与Java堆区分开来。</p>
<p>对于习惯在HotSpot虚拟机上开发和部署程序的开发者来说，很多人愿意把方法区称为&ldquo;永久代&rdquo;（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已。</p>
<p>Java虚拟机规范对这个区域的限制非常宽松，除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展外，还可以选择不实现垃圾收集。相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如永久代的名字一样&ldquo;永久&rdquo;存在了。这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收&ldquo;成绩&rdquo;比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是这部分区域的回收确实是有必要的。</p>
<p>根据Java虚拟机规范的规定，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。&nbsp;</p>
<h3 id="blogTitle8">3 程序计数器</h3>
<p>程序计数器（Program Counter Register）是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，各种虚拟机可能会通过一些更高效的方式去实现），字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。&nbsp;<br />由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为&ldquo;线程私有&rdquo;的内存。&nbsp;<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie方法，这个计数器值则为空（Undefined）。</p>
<p>此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。</p>
<h3 id="blogTitle9">4 VM栈</h3>
<p>与程序计数器一样，Java虚拟机栈（Java Virtual Machine Stacks）也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型：每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。&nbsp;</p>
<p>局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，根据不同的虚拟机实现，它可能是一个指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或者其他与此对象相关的位置）和returnAddress类型（指向了一条字节码指令的地址）。</p>
<p>其中64位长度的long和double类型的数据会占用2个局部变量空间（Slot），其余的数据类型只占用1个。局部变量表所需的内存空间在编译期间完成分配，当进入一个方法时，这个方法需要在帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。</p>
<p>在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的虚拟机栈），当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。</p>
<h3 id="blogTitle10">5 本地方法栈</h3>
<p>本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如Sun HotSpot虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError和OutOfMemoryError异常。</p>
<h2>三、GC概述</h2>
<p class="p">垃圾收集 Garbage Collection 通常被称为&ldquo;GC&rdquo;，它诞生于1960年 MIT 的 Lisp 语言，经过半个多世纪，目前已经十分成熟了。</p>
<p class="p">jvm&nbsp;中，程序计数器、虚拟机栈、本地方法栈都是随线程而生随线程而灭，栈帧随着方法的进入和退出做入栈和出栈操作，实现了自动的内存清理，因此，我们的<strong>内存垃圾回收主要集中于 java 堆和方法区中</strong>，在程序运行期间，这部分内存的分配和使用都是动态的。</p>
<h3 class="p"><strong>3.1GC是什么</strong></h3>
<p>GC其实是一种自动的内存管理工具，其行为主要包括2步</p>
<ul>
<li>在Java堆中，为新创建的对象分配空间</li>
<li>在Java堆中，回收没用的对象占用的空间</li>







</ul>
<h3><strong>3.2为什么需要GC</strong></h3>
<p>释放开发人员的生产力</p>
<h3><strong>3.3为什么需要多种GC</strong></h3>
<p>首先，Java平台被部署在各种各样的硬件资源上，其次，在Java平台上部署和运行着各种各样的应用，并且用户对不同的应用的&nbsp;<em>性能指标</em>&nbsp;(吞吐率和延迟) 预期也不同，为了满足不同应用的对内存管理的不同需求，JVM提供了多种GC以供选择</p>
<p>性能指标</p>
<ul>
<li>最大停顿时长：垃圾回收导致的应用停顿时间的最大值</li>
<li>吞吐率：垃圾回收停顿时长和应用运行总时长的比例</li>






</ul>
<p>不同的GC能满足不同应用不同的性能需求，现有的GC包括：</p>
<ul>
<li>序列化GC(serial garbage collector)：适合占用内存少的应用</li>
<li>并行GC 或 吞吐率GC(parallel or throughput garbage collector)：适合占用内存较多，多CPU，追求高吞吐率的应用</li>
<li>并发GC：适合占用内存较多，多CPU的应用，对延迟有要求的应用</li>









</ul>
<h3>3.4对象存活的判断</h3>
<p class="p">判断对象是否存活一般有两种方式：</p>
<p class="p"><strong>引用计数</strong>：每个对象有一个引用计数属性，新增一个引用时计数加1，引用释放时计数减1，计数为0时可以回收。此方法简单，缺点是无法解决对象相互循环引用的问题。</p>
<p class="p"><strong>可达性分析（Reachability Analysis）</strong>：从GC Roots开始向下搜索，搜索所走过的路径称为引用链。当一个对象到GC Roots没有任何引用链相连时，则证明此对象是不可用的。不可达对象。</p>
<blockquote>
<p class="p">在Java语言中，GC Roots包括：</p>
<p class="p">&nbsp; 虚拟机栈中引用的对象。</p>
<p class="p">&nbsp; 方法区中类静态属性实体引用的对象。</p>
<p class="p">&nbsp; 方法区中常量引用的对象。</p>
<p class="p">&nbsp; 本地方法栈中JNI引用的对象。</p>









</blockquote>
<p>由于循环引用的问题，一般采用跟踪（<strong>可达性分析</strong>）方法</p>
<h2>四、垃圾回收算法</h2>
<h3>4.1 标记 -清除算法</h3>
<p>&ldquo;标记-清除&rdquo;（Mark-Sweep）算法，如它的名字一样，算法分为&ldquo;标记&rdquo;和&ldquo;清除&rdquo;两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。之所以说它是最基础的收集算法，是因为后续的收集算法都是基于这种思路并对其缺点进行改进而得到的。</p>
<p class="p">它的主要缺点有两个：一个是效率问题，标记和清除过程的效率都不高；另外一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201807/1385722-20180730144823609-117728021.png" alt="" /></p>
<h3>4.2 复制算法</h3>
<p>&ldquo;复制&rdquo;（Copying）的收集算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。</p>
<p>这样使得每次都是对其中的一块进行内存回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。只是这种算法的代价是将内存缩小为原来的一半，持续复制长生存期的对象则导致效率降低。</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201807/1385722-20180730144952080-1398471924.png" alt="" /></p>
<h3>4.3 标记-整理算法</h3>
<p>复制收集算法在对象存活率较高时就要执行较多的复制操作，效率将会变低。更关键的是，如果不想浪费50%的空间，就需要有额外的空间进行分配担保，以应对被使用的内存中所有对象都100%存活的极端情况，所以在老年代一般不能直接选用这种算法。</p>
<p>根据老年代的特点，有人提出了另外一种&ldquo;标记-整理&rdquo;（Mark-Compact）算法，标记过程仍然与&ldquo;标记-清除&rdquo;算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存</p>
<p><img src="https://images2018.cnblogs.com/blog/1385722/201807/1385722-20180730145031632-1214395709.png" alt="" /></p>
<h3>4.4 分代收集算法</h3>
<p>分代收集法是目前大部分JVM所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域，一般情况下将GC堆划分为老生代(Tenured/Old Generation)和新生代(Young Generation)。老生代的特点是每次垃圾回收时只有少量对象需要被回收，新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因此可以根据不同区域选择不同的算法。</p>
<p>目前大部分JVM的GC对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，但通常并不是按照1：1来划分新生代。一般将新生代划分为一块较大的Eden空间和两个较小的Survivor空间(From Space, To Space)，每次使用Eden空间和其中的一块Survivor空间，当进行回收时，将该两块空间中还存活的对象复制到另一块Survivor空间中。</p>
<p><img src="https://images2015.cnblogs.com/blog/989246/201704/989246-20170406170311707-1412704605.jpg" alt="" /></p>
<p>而老生代因为每次只回收少量对象，因而采用Mark-Compact算法。</p>
<p>对象的内存分配主要在新生代的Eden Space和Survivor Space的From Space(Survivor目前存放对象的那一块)，少数情况会直接分配到老生代。当新生代的Eden Space和From Space空间不足时就会发生一次GC，进行GC后，Eden Space和From Space区的存活对象会被挪到To Space，然后将Eden Space和From Space进行清理。如果To Space无法足够存储某个对象，则将这个对象存储到老生代。在进行GC后，使用的便是Eden Space和To Space了，如此反复循环。当对象在Survivor区躲过一次GC后，其年龄就会+1。默认情况下年龄到达15的对象会被移到老生代中。</p>
<h2 align="justify">五、垃圾收集器</h2>
<p>如果说收集算法是内存回收的方法论，垃圾收集器就是内存回收的具体实现，不同厂商、不同版本的虚拟机实现差别很大，HotSpot中包含的收集器如下：</p>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430154441316-1293727491.png" alt="" /></p>
<h3>5.1 Serial收集器</h3>
<p align="justify"><strong>串行收集器</strong>是最古老，最稳定以及效率高的收集器，可能会产生较长的停顿，只使用一个线程去回收。新生代、老年代使用串行回收；新生代复制算法、老年代标记-压缩；垃圾收集的过程中会Stop The World（服务暂停）</p>
<p align="justify">参数控制：-XX:+UseSerialGC&nbsp;&nbsp;串行收集器</p>
<p align="justify"><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430154734737-1197475351.png" alt="" /></p>
<h3>5.2 ParNew收集器</h3>
<p align="justify">ParNew收集器其实就是Serial收集器的多线程版本。新生代并行，老年代串行；新生代复制算法、老年代标记-压缩</p>
<p align="justify">参数控制：-XX:+UseParNewGC&nbsp;&nbsp;ParNew收集器</p>
<p align="justify">-XX:ParallelGCThreads&nbsp;限制线程数量</p>
<p align="justify"><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430155050197-460365340.png" alt="" /></p>
<h3>5.3 Parallel收集器</h3>
<p align="justify">Parallel Scavenge收集器类似ParNew收集器，Parallel收集器更关注系统的吞吐量。可以通过参数来打开自适应调节策略，虚拟机会根据当前系统的运行情况收集性能监控信息，动态调整这些参数以提供最合适的停顿时间或最大的吞吐量；也可以通过参数控制GC的时间不大于多少毫秒或者比例；新生代复制算法、老年代标记-压缩</p>
<p align="justify">参数控制：-XX:+UseParallelGC&nbsp;&nbsp;使用Parallel收集器+ 老年代串行</p>
<p align="justify"><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430155431788-84955319.png" alt="" width="1000" /></p>
<h3>5.4 CMS收集器</h3>
<p align="justify">CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。目前很大一部分的Java应用都集中在互联网站或B/S系统的服务端上，这类应用尤其重视服务的响应速度，希望系统停顿时间最短，以给用户带来较好的体验。</p>
<p align="justify">从名字（包含&ldquo;Mark Sweep&rdquo;）上就可以看出CMS收集器是基于&ldquo;标记-清除&rdquo;算法实现的，它的运作过程相对于前面几种收集器来说要更复杂一些，整个过程分为4个步骤，包括：&nbsp;</p>
<p align="justify">初始标记（CMS initial mark）</p>
<p align="justify">并发标记（CMS concurrent mark）</p>
<p align="justify">重新标记（CMS remark）</p>
<p align="justify">并发清除（CMS concurrent sweep）</p>
<p align="justify">&nbsp;其中初始标记、重新标记这两个步骤仍然需要&ldquo;Stop The World&rdquo;。初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，并发标记阶段就是进行GC Roots Tracing的过程，而重新标记阶段则是为了修正并发标记期间，因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。&nbsp;<br />&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 由于整个过程中耗时最长的并发标记和并发清除过程中，收集器线程都可以与用户线程一起工作，所以总体上来说，CMS收集器的内存回收过程是与用户线程一起并发地执行。老年代收集器（新生代使用ParNew）</p>
<p align="justify">&nbsp;&nbsp;优点:并发收集、低停顿&nbsp;</p>
<p align="justify">&nbsp;&nbsp;&nbsp;缺点：产生大量空间碎片、并发阶段会降低吞吐量</p>
<p align="justify">&nbsp;&nbsp;&nbsp;参数控制：-XX:+UseConcMarkSweepGC&nbsp;&nbsp;使用CMS收集器</p>
<p align="justify">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-XX:+ UseCMSCompactAtFullCollection&nbsp;Full&nbsp;GC后，进行一次碎片整理；整理过程是独占的，会引起停顿时间变长</p>
<p align="justify">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-XX:+CMSFullGCsBeforeCompaction&nbsp;&nbsp;设置进行几次Full GC后，进行一次碎片整理</p>
<p align="justify">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-XX:ParallelCMSThreads&nbsp;&nbsp;设定CMS的线程数量（一般情况约等于可用CPU数量）</p>
<p align="justify"><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430155615448-2073405176.png" alt="" width="1000" /></p>
<h3>5.5 G1收集器</h3>
<p align="justify">G1是目前技术发展的最前沿成果之一，HotSpot开发团队赋予它的使命是未来可以替换掉JDK1.5中发布的CMS收集器。与CMS收集器相比G1收集器有以下特点：</p>
<p align="justify">1.&nbsp;空间整合，G1收集器采用标记整理算法，不会产生内存空间碎片。分配大对象时不会因为无法找到连续空间而提前触发下一次GC。</p>
<p align="justify">2.&nbsp;可预测停顿，这是G1的另一大优势，降低停顿时间是G1和CMS的共同关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为N毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒，这几乎已经是实时Java（RTSJ）的垃圾收集器的特征了。</p>
<p align="justify">上面提到的垃圾收集器，收集的范围都是整个新生代或者老年代，而G1不再是这样。使用G1收集器时，Java堆的内存布局与其他收集器有很大差别，它将整个Java堆划分为多个大小相等的独立区域（Region），虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔阂了，它们都是一部分（可以不连续）Region的集合。</p>
<h4 id="G1对Heap的划分">G1对Heap的划分</h4>
<blockquote>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430155951152-2106136185.png" alt="" /></p>
<p>&nbsp;</p>









</blockquote>
<p>G1的新生代收集跟ParNew类似，当新生代占用达到一定比例的时候，开始出发收集。和CMS类似，G1收集器收集老年代对象会有短暂停顿。</p>
<h4>收集步骤</h4>
<p>1、标记阶段，首先初始标记(Initial-Mark),这个阶段是停顿的(Stop the World Event)，并且会触发一次普通Mintor GC。对应GC log:GC pause (young) (inital-mark)</p>
<p>2、Root Region Scanning，程序运行过程中会回收survivor区(存活到老年代)，这一过程必须在young GC之前完成。</p>
<p>3、Concurrent Marking，在整个堆中进行并发标记(和应用程序并发执行)，此过程可能被young GC中断。在并发标记阶段，若发现区域对象中的所有对象都是垃圾，那个这个区域会被立即回收(图中打X)。同时，并发标记过程中，会计算每个区域的对象活性(区域中存活对象的比例)。</p>
<blockquote>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430160141901-1411612026.png" alt="" /></p>
<p>&nbsp;</p>









</blockquote>
<p>&nbsp;</p>
<p>4、Remark, 再标记，会有短暂停顿(STW)。再标记阶段是用来收集 并发标记阶段 产生新的垃圾(并发阶段和应用程序一同运行)；G1中采用了比CMS更快的初始快照算法:snapshot-at-the-beginning (SATB)。</p>
<p>5、Copy/Clean up，多线程清除失活对象，会有STW。G1将回收区域的存活对象拷贝到新区域，清除Remember Sets，并发清空回收区域并把它返回到空闲区域链表中。</p>
<blockquote>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430160158306-1501053707.png" alt="" /></p>
<p>&nbsp;</p>









</blockquote>
<p>6、复制/清除过程后。回收区域的活性对象已经被集中回收到深蓝色和深绿色区域。</p>
<blockquote>
<p><img src="https://images2018.cnblogs.com/blog/1228818/201804/1228818-20180430160215565-69737884.png" alt="" /></p>
<p>&nbsp;</p>









</blockquote>
<h2>六、常用的收集器组合&nbsp;</h2>
<table border="1" cellspacing="0" cellpadding="2">
<tbody>
<tr>
<td valign="top">&nbsp;</td>
<td valign="top">新生代GC策略</td>
<td valign="top">年老代GC策略</td>
<td valign="top">说明</td>









</tr>
<tr>
<td valign="top">组合1</td>
<td valign="top">Serial</td>
<td valign="top">Serial Old</td>
<td valign="top">Serial和Serial Old都是单线程进行GC，特点就是GC时暂停所有应用线程。</td>









</tr>
<tr>
<td valign="top">组合2</td>
<td valign="top">Serial</td>
<td valign="top">CMS+Serial Old</td>
<td valign="top">CMS（Concurrent Mark Sweep）是并发GC，实现GC线程和应用线程并发工作，不需要暂停所有应用线程。另外，当CMS进行GC失败时，会自动使用Serial Old策略进行GC。</td>









</tr>
<tr>
<td valign="top">组合3</td>
<td valign="top">ParNew</td>
<td valign="top">CMS</td>
<td valign="top">
<div>使用-XX:+UseParNewGC选项来开启。ParNew是Serial的并行版本，可以指定GC线程数，默认GC线程数为CPU的数量。可以使用-XX:ParallelGCThreads选项指定GC的线程数。</div>
<div>如果指定了选项-XX:+UseConcMarkSweepGC选项，则新生代默认使用ParNew GC策略。</div>









</td>









</tr>
<tr>
<td valign="top">组合4</td>
<td valign="top">ParNew</td>
<td valign="top">Serial Old</td>
<td valign="top">使用-XX:+UseParNewGC选项来开启。新生代使用ParNew GC策略，年老代默认使用Serial Old GC策略。</td>









</tr>
<tr>
<td valign="top">组合5</td>
<td valign="top">Parallel Scavenge</td>
<td valign="top">Serial Old</td>
<td valign="top">Parallel Scavenge策略主要是关注一个可控的吞吐量：应用程序运行时间 / (应用程序运行时间 + GC时间)，可见这会使得CPU的利用率尽可能的高，适用于后台持久运行的应用程序，而不适用于交互较多的应用程序。</td>









</tr>
<tr>
<td valign="top">组合6</td>
<td valign="top">Parallel Scavenge</td>
<td valign="top">Parallel Old</td>
<td valign="top">
<div>Parallel Old是Serial Old的并行版本</div>
<p>&nbsp;</p>









</td>









</tr>
<tr>
<td valign="top">组合7</td>
<td valign="top">G1GC</td>
<td valign="top">G1GC</td>
<td valign="top">-XX:+UnlockExperimentalVMOptions -XX:+UseG1GC&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#开启<br />-XX:MaxGCPauseMillis =50&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#暂停时间目标<br />-XX:GCPauseIntervalMillis =200&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#暂停间隔目标<br />-XX:+G1YoungGenSize=512m&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#年轻代大小<br />-XX:SurvivorRatio=6&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;#幸存区比例<br /><br /></td>









</tr>









</tbody>








</table></div>

</body>
</html>
